home *** CD-ROM | disk | FTP | other *** search
/ Amiga CD-ROM Collection / Amiga CD-ROM Collection - Auge 4000 and Cactus and Demo Util.iso / auge4000 / 18 / virusx / virusx.c < prev    next >
C/C++ Source or Header  |  1988-01-19  |  13KB  |  491 lines
  1.  
  2. /* VirusX - by Steve Tibbett
  3.  
  4.     The complete Virus Elimination System!
  5.  
  6.         Please - if you find a new virus, Send me a copy!
  7.         (And warn me it's on the disk!).  I want to keep
  8.         this program current.  (Feel free to put something
  9.         neat (but not copyrighted) on the disk also!
  10. */
  11.  
  12. /* - Ok, it's not the cleanest code in the world - it was written in two
  13.      days, for a specific purpose, and it works!                         */
  14.  
  15. struct Port *diskport;         /* disk's port.*/
  16. struct IOStdReq *diskreq;    /* disk's IOStdReq */
  17.  
  18. int DisksChecked, DisksInstalled, SCAFound;    /* for title bar info */
  19.  
  20. char titlebuffer[80];
  21.  
  22.  
  23. /* Who needs includes with Aztec?  Everything's precompiled! */
  24.  
  25. /* Amount of boot code we've got (approx):  */
  26. #define BSIZE 40
  27.  
  28. int ChangeCount[4];        /* TD_CHANGECOUNT for all 4 drives */
  29.  
  30. int LastSum;            /* Used in the checksumming */
  31.  
  32. int CheckDrives;        /* Boolean, from the command line */
  33.  
  34. int error;            /* sort of a temporary variable sort of */
  35.  
  36. unsigned char diskbuffer[3*512];/* Everything ends up in here. 
  37.                    I suppose I should have AllocMem'ed this,
  38.                    but it's SO easy this way */
  39.  
  40. /* Warning messages.  These messages get modified before being displayed
  41.    (Unless you DO have a DF9:) */
  42. char TEXTPTR[] = "Danger:  The disk in DF9: is";
  43. char NBCTEXT[] = "Danger:  The disk in DF9: has"; 
  44.  
  45.  
  46. /* This is a byte by byte copy of working boot block code.  Check it
  47.    out if you like.  This is what gets written back to the disk when you
  48.    ask VirusX to fix a disk. */
  49.  
  50. unsigned char bootblock[] = { 'D', 'O', 'S', 0, 0xc0, 0x20, 0x0f, 0x19, 
  51. 0, 0, 3, 0x70, 0x43, 0xfa, 0, 0x18, 
  52. 0x4e, 0xae, 0xff, 0xa0, 0x4a, 0x80, 0x67, 0x0a, 0x20, 0x40, 0x20, 0x68, 
  53. 0x00, 0x16, 0x70, 0x00, 0x4e, 0x75, 0x70, 0xff, 0x60, 0xfa, 0x64, 
  54. 0x6f, 0x73, 0x2e, 0x6c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79,0,0,0,0,0};
  55.  
  56. /* for IntuiText's */
  57. char def_font[] ="topaz.font";
  58.  
  59. struct TextAttr TxtAt_Plain = {    (UBYTE *)def_font, 8,
  60.     FS_NORMAL, FPF_ROMFONT};
  61.  
  62. /***  Non SCA warning requester IntuiText's ***/
  63. struct IntuiText Body2 = {
  64.    0, 1,     JAM2,          20,18,        &TxtAt_Plain,(UBYTE *)"Nonstandard Boot Code!", NULL };
  65. struct IntuiText Body1 = {
  66.    0, 1,        JAM2,          20, 8, &TxtAt_Plain,      (UBYTE *)NBCTEXT, &Body2 };
  67. struct IntuiText Pos = {
  68.    0, 1,     JAM2,           7,3,        &TxtAt_Plain, "Remove it", NULL };
  69. struct IntuiText Neg = {
  70.    0, 1,    JAM2,           7,3,        &TxtAt_Plain, "Ignore it", NULL };
  71.  
  72. /***** SCA Danger Requester IntuiText's ******/
  73. struct IntuiText SCABody2 = {
  74.    0, 1,     JAM2,          20,18,        &TxtAt_Plain,(UBYTE *) "infected with an SCA Virus!!", NULL };
  75. struct IntuiText SCABody = {
  76.    0, 1,        JAM2,          20, 8, &TxtAt_Plain,      (UBYTE *)TEXTPTR, &SCABody2 };
  77. struct IntuiText SCAPos = {
  78.    0, 1,     JAM2,           7,3,        &TxtAt_Plain, "Remove it", NULL };
  79. struct IntuiText SCANeg = {
  80.    0, 1,    JAM2,           7,3,        &TxtAt_Plain, "Ignore it", NULL };
  81.  
  82. /***** Write Protect Error Requester IntuiText's ******/
  83. struct IntuiText ERRBody2 = {
  84.    0, 1,     JAM2,          20,18,        &TxtAt_Plain,(UBYTE *) "Write Protected.", NULL };
  85. struct IntuiText ERRBody = {
  86.    0, 1,        JAM2,          20, 8, &TxtAt_Plain,      (UBYTE *)"DISK ERROR:  Disk is", &ERRBody2 };
  87. struct IntuiText ERRPos = {
  88.    0, 1,     JAM2,           7,3,        &TxtAt_Plain, "Retry", NULL };
  89. struct IntuiText ERRNeg = {
  90.    0, 1,    JAM2,           7,3,        &TxtAt_Plain, "Cancel", NULL };
  91.  
  92. /***** Rewrite block?  Really? ******/
  93. struct IntuiText REWBody3 = {
  94.    0, 1,     JAM2,          20,28,        &TxtAt_Plain,(UBYTE *) "boot sectors?", NULL };
  95. struct IntuiText REWBody2 = {
  96.    0, 1,     JAM2,          20,18,        &TxtAt_Plain,(UBYTE *) "rewrite that disk's boot", &REWBody3};
  97. struct IntuiText REWBody = {
  98.    0, 1,        JAM2,          20, 8, &TxtAt_Plain,      (UBYTE *)"Are you sure you want to", &REWBody2 };
  99. struct IntuiText REWPos = {
  100.    0, 1,     JAM2,           7,3,        &TxtAt_Plain, "Yes", NULL };
  101. struct IntuiText REWNeg = {
  102.    0, 1,    JAM2,           7,3,        &TxtAt_Plain, "No!", NULL };
  103.  
  104. struct IntuitionBase *IntuitionBase;
  105. struct GfxBase *GfxBase;
  106. struct Window *LittleWindow;
  107. struct IntuiMessage *Message;
  108. struct RastPort *RP;
  109.  
  110. int Keepgoing;        /* a boolean flag.  it's false when we want out. */
  111. int Class, Code;    /* for storing IntuiNewspaper things. */
  112. int x, y, i;        /* left over from my using Basic */
  113.  
  114. /*** The Newwindow Structure. ***/
  115.  
  116. char TITLETEXT[] = "VirusX 1.0 by Steve Tibbett";
  117. struct NewWindow NewLittleWindow = {
  118.     128,    /* Left, Top, Width, Height */    
  119.     0,        
  120.     300,        
  121.     10,        
  122.     0,    /* Frontpen, Backpen */    
  123.     1,        
  124. DISKINSERTED | CLOSEWINDOW | VANILLAKEY | MOUSEBUTTONS,    /* IDCMP Flagz */
  125. WINDOWDRAG | WINDOWDEPTH | RMBTRAP | WINDOWCLOSE | NOCAREREFRESH, /* Windo Flagz */    
  126.     NULL,        
  127.     NULL,        
  128.     TITLETEXT,    /* My name.  Dont touch it!! */
  129.     NULL,        
  130.     NULL,        
  131.     0,        
  132.     0,        
  133.     0,        
  134.     0,        
  135.     WBENCHSCREEN,    
  136.     };
  137. /*********************Da Beginnin*************************/
  138. main(argc, argv)
  139. int argc;
  140. char *argv[];
  141. {
  142. int OldPri;
  143.  
  144.  
  145. /* Come on, folks, is intuition never NOT going to be available???? */
  146. IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
  147. GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0);
  148.  
  149.  
  150. /* If checkdrives is true, later on it means we want to check all the drives
  151.    with disks in them for viruses. */
  152.  
  153. CheckDrives = FALSE;
  154.  
  155. if (argc == 0)    /* If argc == 0, we're a Workbench deryvatuv */
  156.     {
  157.     CheckDrives = TRUE;    /* If we're workbench, we want to check drives */
  158.     }
  159.     else
  160.     {
  161.     for (i = 0; i < argc; i++)
  162.         {
  163.         if (argv[i][0] == '-')    /* if we find a -C, we want CheckDrives */
  164.             {
  165.             if (argv[i][1] == 'c' | argv[i][1] == 'C') CheckDrives = TRUE;
  166.             };
  167.         if (argv[i][0] == '?')    /* HELP ME! */
  168.             {
  169.             puts("Usage: VirusX [-C]\n");
  170.             puts("      -c checks all drives for Virus upon execution\n");
  171.             exit(FALSE);
  172.             };
  173.         };
  174.     };
  175.  
  176. /* Save OldPri so we can restore it later on.  We're so nice. */
  177. OldPri = SetTaskPri(FindTask(0), 19); /* and stick us up high. */
  178. diskport = CreatePort(0,0);
  179. diskreq = CreateStdIO(diskport);
  180.  
  181. SetUp();
  182.  
  183. DoLittle();    /* The main loop.  Do Little.  Ya. */
  184.  
  185. /* restore priorities to saneness, and take off, eh? */
  186. SetTaskPri(FindTask(0), OldPri);
  187.  
  188. DeletePort(diskport);
  189. DeleteStdIO(diskreq);
  190.  
  191. exit(FALSE);
  192. }            
  193.  
  194. /*********************/
  195. DoLittle()
  196. {
  197. register int Code;
  198. register int Class;    /* gee */
  199. register int KG2;    /* KeepGoing 2.  Another booleean. */
  200.  
  201. LittleWindow = OpenWindow(&NewLittleWindow);
  202. if (LittleWindow == NULL) exit(400L);    /* No memory to open little window! */
  203.  
  204. KG2 = TRUE;
  205. RP = LittleWindow->RPort;    /* easier than typing Move(LittleWindow->RP... all
  206.                    the time */
  207.  
  208. if (CheckDrives == TRUE)     /* We'll fake it:  Set changecount to 1000, to*/
  209.     {            /*make people think it's been changed */
  210.     for (x = 0; x < 4; x++) ChangeCount[x] = 1000;
  211.     CheckBlock();        /* CheckBlock() checks boot block for virus. */
  212.     CheckDrives = FALSE;    /* so we don't do it again */
  213.     };
  214.  
  215. SetAPen(RP, 1);
  216. SetBPen(RP, 0);
  217. SetDrMd(RP, JAM2);    /* ya. JAM 2!  Love that name! */
  218.  
  219. while (KG2 == TRUE)
  220.     {
  221.     sprintf(titlebuffer, "VirusX: Disks Checked: %d   Disks Installed: %d   Viruses Found: %d", DisksChecked, DisksInstalled, SCAFound);
  222.     SetWindowTitles(LittleWindow, -1, titlebuffer);
  223.     Message = GetMsg(LittleWindow->UserPort);
  224.     while (Message == NULL)
  225.             {
  226.             /* Lets be nice to other tasks!  Ya! */
  227.             Wait(1<<LittleWindow->UserPort->mp_SigBit);
  228.             Message = GetMsg(LittleWindow->UserPort);
  229.             };
  230.     Class = Message->Class;
  231.     Code = Message->Code;
  232.     if (Message != NULL) ReplyMsg(Message);
  233.     
  234.     if (Class == CLOSEWINDOW) 
  235.         {
  236.         CloseWindow(LittleWindow);
  237.         exit(FALSE);
  238.         };
  239.  
  240.     if (Class == DISKINSERTED) CheckBlock();
  241.     };
  242.  
  243. /* KG2 = false, we fell thru to here.  Ow. */
  244.  
  245. CloseWindow(LittleWindow);
  246. return;
  247. }
  248.  
  249. /**********************/
  250. puts(str)        /* outputs a string, but is REAL small. */
  251. char *str[];
  252. {
  253.     Write(Output(), str, strlen(str));
  254. }
  255.  
  256. /********************/
  257. /* Opens trackdisk, finds out who's out there, and sets Changecount up accordioningly. */
  258. /********************/
  259.  
  260. SetUp()
  261. {
  262.  
  263. for (x = 0; x < 4; x++)    /* go thru all 4 possible drives */
  264.     {
  265.     ChangeCount[x] = 0;
  266.     error = OpenDevice("trackdisk.device",x,diskreq,0);
  267.     if (error > 0) continue;    /* no drive here */
  268.     diskreq->io_Command = TD_CHANGENUM;    
  269.     error = DoIO(diskreq);        
  270.     ChangeCount[x] = diskreq->io_Actual;    /* save changecount for later */
  271.     CloseDevice(diskreq);
  272.     };
  273.  
  274. }
  275.  
  276. /********************************/
  277. /* This routine returns which drive changed disks lately */
  278. /********************************/
  279. WhoChanged()
  280. {
  281. int RetVal;    /* The value we'll return */
  282.  
  283. RetVal = -1;    /* return -1 if all else fails */
  284. for (x = 0; x < 4; x++)
  285.     {
  286.     if (ChangeCount[x] == 0) continue;    /* no drive here */
  287.     error = OpenDevice("trackdisk.device",x,diskreq,0);
  288.     if (error > 0) continue;    /* no drive here */
  289.     
  290.     diskreq->io_Command = TD_CHANGESTATE;
  291.     DoIO(diskreq);
  292.     if (diskreq->io_Actual != 0) 
  293.         {
  294.         continue;
  295.         };
  296.  
  297.     diskreq->io_Command = TD_CHANGENUM;
  298.     DoIO(diskreq);
  299.     if (diskreq->io_Actual != ChangeCount[x]) 
  300.         {
  301.         RetVal = x;
  302.         ChangeCount[x] = diskreq->io_Actual;
  303.         CloseDevice(diskreq);
  304.         goto Out;
  305.         };
  306.     CloseDevice(diskreq);
  307.     };
  308. Out:;
  309. return(RetVal);
  310. }
  311. /********************************/
  312.  
  313. CheckBlock()
  314. {
  315. int Sum, Bootable, Virus;   /* Virus is a flag, Bootable is a flag, Sum the cksum. */
  316. int a, Unit;
  317. int SCA;    /* don't get scared, it's just a flag. */
  318.  
  319. Unit = WhoChanged();
  320.  
  321. CheckAgainYouFool:;    /* oh oh, a label.  Could be a goto later on! */
  322.  
  323. DisksChecked++;
  324.  
  325. SCA = FALSE;
  326.  
  327. /* Unit # to open is returned by "WhoChanged()" up above. */
  328. if (Unit == -1) return;
  329. error = OpenDevice("trackdisk.device",Unit,diskreq,0);
  330. if (error > 0) return;
  331.  
  332. /* I've heard stories that pulling a read request to block zero with a
  333.    length of 1024 will cause the virus to write itself back.  Not taking
  334.    any chances. */
  335.  
  336. diskreq->io_Command = CMD_READ;
  337. diskreq->io_Data = diskbuffer;
  338. diskreq->io_Length = 3*512;
  339. diskreq->io_Offset = 0;
  340. DoIO(diskreq);
  341.  
  342. diskreq->io_Length = 0;
  343. diskreq->io_Command = TD_MOTOR;
  344. DoIO(diskreq);                /* turn off motor */
  345.  
  346. if (diskreq->io_Error > 19) return;    /* disk error, lemme out */
  347. CloseDevice(diskreq);
  348.  
  349. Sum = 0;
  350. for (a=0; a<1024; a=a+4)
  351.     {
  352.     LastSum = Sum;
  353.     Sum = Sum + diskbuffer[a+3];
  354.     Sum = Sum + (diskbuffer[a+2] * 256);
  355.     Sum = Sum + (diskbuffer[a+1] * 65536);
  356.     Sum = Sum + (diskbuffer[a] * (65536 * 256));
  357.     if (LastSum > Sum) Sum++;    /* took me a while to figger this out */
  358.     }
  359.  
  360. if (Sum != 0) return;    /* if it's not bootable, we DONT want it! */
  361.  
  362. /* check specifically for SCA virus */
  363. if (diskbuffer[8] == 'C')
  364.     if (diskbuffer[9] == 'H')
  365.         if (diskbuffer[10] == 'W')
  366.                 {
  367.                 SCA = TRUE;    /* CHW is part of SCA virus */
  368.                 SCAFound++;
  369.                 };
  370.  
  371. /* compare boot block with real boot block.  If it's not, notify God. */
  372. Virus = FALSE;
  373. for (x = 0; x < 39; x++) /* nuum of lements in bootblock */
  374.     {
  375.     if (diskbuffer[8+x] != bootblock[8+x])
  376.         {    
  377.         Virus = TRUE;
  378.         };
  379.     };
  380.  
  381. /* Oh no, a Virus! */
  382. if (Virus == TRUE) 
  383.     {
  384.     /* Oh no, it's the SCA Virus! */
  385.     if (SCA != TRUE)
  386.         {
  387.         Delay(1);
  388.         NBCTEXT[23] = '0'+Unit; /* change DF9: to real drive in text */
  389.         error = AutoRequest(LittleWindow, &Body1, &Pos, &Neg, 0, 0, 320, 75);
  390.         if (error == TRUE) DoInstall(Unit); /* user wants it neutered. */
  391.         Delay(1);
  392.         }
  393.       else
  394.         {
  395.         /* Phew, just a nonstandard boot block, probably */
  396.         Delay(1);
  397.         TEXTPTR[23] = '0'+Unit;
  398.         error = AutoRequest(LittleWindow, &SCABody, &SCAPos, &SCANeg, 0, 0, 320, 75);
  399.         if (error == TRUE) DoInstall(Unit);    /* user wants it fixed. */
  400.         Delay(1);
  401.         };
  402.     };
  403.  
  404.  
  405. Unit = WhoChanged();    /* more than one disk was changed. check again */
  406. if (Unit != -1) goto CheckAgainYouFool;
  407. }
  408.  
  409. /********************************/
  410. /* This is where the boot code gets changed */
  411. /********************************/
  412. DoInstall(un)
  413. int un;    /* unit to write to */
  414. {
  415. register int x;
  416. register int Sum;
  417. int err, a;
  418.  
  419. /* Rewrite disk?  Really?  */
  420. error = AutoRequest(LittleWindow, &REWBody, &REWPos, &REWNeg, 0, 0, 320, 75);
  421. if (error != TRUE) return;    /* user changed his brain. */
  422.  
  423. DisksInstalled++;
  424.  
  425. for (x = 0; x < 1024; x++)
  426.     diskbuffer[x] = 0;    /* clear diskbuffer to zero.  clean. */
  427.  
  428. for (x = 0; x < 50; x++)
  429.     {
  430.     diskbuffer[x] = bootblock[x];    /* copy boot code into buffer */
  431.     };
  432.  
  433. /* Write it ! */
  434.  
  435. error = OpenDevice("trackdisk.device", un,diskreq,0);
  436. if (error > 0) return;
  437.  
  438. diskreq->io_Command = CMD_READ;
  439. diskreq->io_Data = diskbuffer;
  440. diskreq->io_Length = 512;
  441. diskreq->io_Offset = 44*512;
  442. DoIO(diskreq);
  443.  
  444. trygain:        /* GOTO!  A GOTO!  OH NOOOO! */
  445.  
  446. diskreq->io_Command = TD_PROTSTATUS;
  447. DoIO(diskreq);        /* check if disk is write protected */
  448.  
  449. if (diskreq->io_Actual != 0)
  450.     {
  451.     error = AutoRequest(LittleWindow, &ERRBody, &ERRPos, &ERRNeg, 0, 0, 320, 75);
  452.     if (error == TRUE) /* error is true or false, depending on user */
  453.         {
  454.         goto trygain;
  455.         };
  456.     CloseDevice(diskreq);
  457.     return;    /* unrecoverable write protect error!!!!!!!!! */
  458.     };
  459.  
  460. diskreq->io_Length = 1024; /* here we go! */
  461. diskreq->io_Data = &diskbuffer[0];  
  462. diskreq->io_Command = CMD_WRITE;
  463. diskreq->io_Offset = 0L;
  464. DoIO(diskreq);
  465.  
  466. diskreq->io_Command = CMD_UPDATE;    /* flush buffer to disk */
  467. DoIO(diskreq);
  468. error = diskreq->io_Error;
  469.  
  470. diskreq->io_Length = 0;
  471. diskreq->io_Command = ETD_MOTOR;
  472. DoIO(diskreq);                /* turn off motor */
  473.  
  474. CloseDevice(diskreq);
  475.  
  476. if (error > 19) 
  477.     {
  478.     SetWindowTitles(LittleWindow, "Error, Nothing Done.", -1);
  479.     } 
  480.     else
  481.     {
  482.     SetWindowTitles(LittleWindow, "Disk Healed.", -1);
  483.     };
  484.  
  485. Delay(100);
  486. SetWindowTitles(LittleWindow, TITLETEXT, -1);
  487.  
  488. }
  489. /************************/
  490.  
  491.